}
static void
-released_cb (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- gboolean *clicked)
+released_cb (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ gboolean *clicked)
{
*clicked = TRUE;
}
GDK_SEAT_CAPABILITY_ALL_POINTING,
FALSE, cursor, NULL, NULL, NULL) == GDK_GRAB_SUCCESS)
{
- GtkGesture *gesture = gtk_gesture_multi_press_new ();
+ GtkGesture *gesture = gtk_gesture_click_new ();
gboolean clicked = FALSE;
g_signal_connect (gesture, "released",
G_CALLBACK (drag_data_received), image);
/* context menu on image */
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed", G_CALLBACK (pressed_cb), image);
gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (gesture));
G_CALLBACK (drag_data_received), image);
/* context menu on image */
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed", G_CALLBACK (pressed_cb), image);
gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (gesture));
G_DEFINE_TYPE (DemoTaggedEntryTag, demo_tagged_entry_tag, GTK_TYPE_WIDGET)
static void
-on_released (GtkGestureMultiPress *gesture,
+on_released (GtkGestureClick *gesture,
int n_press,
double x,
double y,
- DemoTaggedEntryTag *tag)
+ DemoTaggedEntryTag *tag)
{
g_signal_emit (tag, signals[SIGNAL_CLICKED], 0);
}
tag->label = gtk_label_new ("");
gtk_container_add (GTK_CONTAINER (tag->box), tag->label);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "released", G_CALLBACK (on_released), tag);
gtk_widget_add_controller (GTK_WIDGET (tag), GTK_EVENT_CONTROLLER (gesture));
gtk_widget_set_hexpand (fixed, TRUE);
gtk_widget_set_vexpand (fixed, TRUE);
- multipress = gtk_gesture_multi_press_new ();
+ multipress = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (multipress), 0);
g_signal_connect (multipress, "pressed", G_CALLBACK (pressed_cb), NULL);
g_signal_connect (multipress, "released", G_CALLBACK (released_cb), NULL);
gint y);
static void
-released_cb (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkWidget *text_view)
+released_cb (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkWidget *text_view)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
g_signal_connect (controller, "key-pressed", G_CALLBACK (key_pressed), view);
gtk_widget_add_controller (view, controller);
- controller = GTK_EVENT_CONTROLLER (gtk_gesture_multi_press_new ());
+ controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ());
g_signal_connect (controller, "released",
G_CALLBACK (released_cb), view);
gtk_widget_add_controller (view, controller);
}
static void
-puzzle_button_pressed (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- GtkWidget *grid)
+puzzle_button_pressed (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ GtkWidget *grid)
{
GtkWidget *child;
int l, t, i;
grid);
gtk_widget_add_controller (GTK_WIDGET (grid), controller);
- controller = GTK_EVENT_CONTROLLER (gtk_gesture_multi_press_new ());
+ controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ());
g_signal_connect (controller, "pressed",
G_CALLBACK (puzzle_button_pressed),
grid);
}
static gboolean
-osd_frame_pressed (GtkGestureMultiPress *gesture,
- int press,
- double x,
- double y,
- gpointer data)
+osd_frame_pressed (GtkGestureClick *gesture,
+ int press,
+ double x,
+ double y,
+ gpointer data)
{
GtkWidget *frame = data;
GtkWidget *osd;
</object>
</child>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<signal name="pressed" handler="osd_frame_pressed" object="osd_frame" swapped="no"/>
</object>
</child>
<xi:include href="xml/gtkgesturesingle.xml" />
<xi:include href="xml/gtkgesturedrag.xml" />
<xi:include href="xml/gtkgesturelongpress.xml" />
- <xi:include href="xml/gtkgesturemultipress.xml" />
+ <xi:include href="xml/gtkgestureclick.xml" />
<xi:include href="xml/gtkgesturepan.xml" />
<xi:include href="xml/gtkgestureswipe.xml" />
<xi:include href="xml/gtkgesturerotate.xml" />
</SECTION>
<SECTION>
-<FILE>gtkgesturemultipress</FILE>
-<TITLE>GtkGestureMultiPress</TITLE>
-GtkGestureMultiPress
-gtk_gesture_multi_press_new
-gtk_gesture_multi_press_set_area
-gtk_gesture_multi_press_get_area
+<FILE>gtkgestureclick</FILE>
+<TITLE>GtkGestureClick</TITLE>
+GtkGestureClick
+gtk_gesture_click_new
+gtk_gesture_click_set_area
+gtk_gesture_click_get_area
<SUBSECTION Standard>
-GTK_TYPE_GESTURE_MULTI_PRESS
-GTK_GESTURE_MULTI_PRESS
-GTK_GESTURE_MULTI_PRESS_CLASS
-GTK_IS_GESTURE_MULTI_PRESS
-GTK_IS_GESTURE_MULTI_PRESS_CLASS
-GTK_GESTURE_MULTI_PRESS_GET_CLASS
+GTK_TYPE_GESTURE_CLICK
+GTK_GESTURE_CLICK
+GTK_GESTURE_CLICK_CLASS
+GTK_IS_GESTURE_CLICK
+GTK_IS_GESTURE_CLICK_CLASS
+GTK_GESTURE_CLICK_GET_CLASS
<SUBSECTION Private>
-gtk_gesture_multi_press_get_type
+gtk_gesture_click_get_type
</SECTION>
<SECTION>
gtk_font_chooser_widget_get_type
gtk_frame_get_type
gtk_gesture_get_type
+gtk_gesture_click_get_type
gtk_gesture_drag_get_type
gtk_gesture_long_press_get_type
-gtk_gesture_multi_press_get_type
gtk_gesture_pan_get_type
gtk_gesture_rotate_get_type
gtk_gesture_single_get_type
}
static void
-pressed (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- GtkWidget *area)
+pressed (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ GtkWidget *area)
{
clear_surface ();
gtk_widget_queue_draw (area);
g_signal_connect (drag, "drag-update", G_CALLBACK (drag_update), drawing_area);
g_signal_connect (drag, "drag-end", G_CALLBACK (drag_end), drawing_area);
- press = gtk_gesture_multi_press_new ();
+ press = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (press), GDK_BUTTON_SECONDARY);
gtk_widget_add_controller (drawing_area, GTK_EVENT_CONTROLLER (press));
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGesture, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGestureDrag, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGestureLongPress, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGestureMultiPress, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGestureClick, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGesturePan, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGestureRotate, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkGestureSingle, g_object_unref)
#include <gtk/gtkfontchooserwidget.h>
#include <gtk/gtkframe.h>
#include <gtk/gtkgesture.h>
+#include <gtk/gtkgestureclick.h>
#include <gtk/gtkgesturedrag.h>
#include <gtk/gtkgesturelongpress.h>
-#include <gtk/gtkgesturemultipress.h>
#include <gtk/gtkgesturepan.h>
#include <gtk/gtkgesturerotate.h>
#include <gtk/gtkgesturesingle.h>
#include "gtkdialogprivate.h"
#include "gtkeventcontrollermotion.h"
#include "gtkeventcontrollerkey.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
/**
guint keycode,
GdkModifierType state,
GtkAboutDialog *about);
-static void text_view_released (GtkGestureMultiPress *press,
+static void text_view_released (GtkGestureClick *press,
int n,
double x,
double y,
}
static void
-text_view_released (GtkGestureMultiPress *gesture,
+text_view_released (GtkGestureClick *gesture,
int n_press,
double x,
double y,
#include "gtkorientable.h"
#include "gtkscrolledwindow.h"
#include "gtklabel.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include <string.h>
#include <glib/gi18n-lib.h>
g_signal_connect (priv->monitor, "changed",
G_CALLBACK (app_info_changed), self);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed",
G_CALLBACK (gtk_app_chooser_row_pressed_cb), self);
#include "gtkactionhelperprivate.h"
#include "gtkcheckbutton.h"
#include "gtkcontainerprivate.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkeventcontrollerkey.h"
#include "gtkimage.h"
#include "gtkintl.h"
}
static void
-multipress_pressed_cb (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkWidget *widget)
+click_pressed_cb (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkWidget *widget)
{
GtkButton *button = GTK_BUTTON (widget);
GtkButtonPrivate *priv = gtk_button_get_instance_private (button);
}
static void
-multipress_released_cb (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkWidget *widget)
+click_released_cb (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkWidget *widget)
{
GtkButton *button = GTK_BUTTON (widget);
GtkButtonPrivate *priv = gtk_button_get_instance_private (button);
}
static void
-multipress_gesture_cancel_cb (GtkGesture *gesture,
- GdkEventSequence *sequence,
- GtkButton *button)
+click_gesture_cancel_cb (GtkGesture *gesture,
+ GdkEventSequence *sequence,
+ GtkButton *button)
{
gtk_button_do_release (button, FALSE);
}
priv->use_underline = FALSE;
priv->child_type = WIDGET_CHILD;
- priv->gesture = gtk_gesture_multi_press_new ();
+ priv->gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->gesture), FALSE);
gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->gesture), TRUE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->gesture), GDK_BUTTON_PRIMARY);
- g_signal_connect (priv->gesture, "pressed", G_CALLBACK (multipress_pressed_cb), button);
- g_signal_connect (priv->gesture, "released", G_CALLBACK (multipress_released_cb), button);
- g_signal_connect (priv->gesture, "cancel", G_CALLBACK (multipress_gesture_cancel_cb), button);
+ g_signal_connect (priv->gesture, "pressed", G_CALLBACK (click_pressed_cb), button);
+ g_signal_connect (priv->gesture, "released", G_CALLBACK (click_released_cb), button);
+ g_signal_connect (priv->gesture, "cancel", G_CALLBACK (click_gesture_cancel_cb), button);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->gesture), GTK_PHASE_CAPTURE);
gtk_widget_add_controller (GTK_WIDGET (button), GTK_EVENT_CONTROLLER (priv->gesture));
#include "gtksnapshot.h"
#include "gtkstylecontextprivate.h"
#include "gtkwidgetprivate.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturedrag.h"
#include "gtkeventcontrollerscroll.h"
#include "gtkeventcontrollerkey.h"
int width,
int height,
int baseline);
-static void gtk_calendar_snapshot (GtkWidget *widget,
- GtkSnapshot *snapshot);
-static void gtk_calendar_button_press (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data);
-static void gtk_calendar_button_release (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data);
+static void gtk_calendar_snapshot (GtkWidget *widget,
+ GtkSnapshot *snapshot);
+static void gtk_calendar_button_press (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data);
+static void gtk_calendar_button_release (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data);
static void gtk_calendar_drag_begin (GtkGestureDrag *gesture,
double x,
double y,
gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (calendar)),
GTK_STYLE_CLASS_VIEW);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (gtk_calendar_button_press), calendar);
g_signal_connect (gesture, "released", G_CALLBACK (gtk_calendar_button_release), calendar);
gtk_widget_add_controller (GTK_WIDGET (calendar), GTK_EVENT_CONTROLLER (gesture));
static void
-gtk_calendar_button_press (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_calendar_button_press (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkCalendar *calendar = user_data;
GtkWidget *widget = GTK_WIDGET (calendar);
}
static void
-gtk_calendar_button_release (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_calendar_button_release (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkCalendar *calendar = user_data;
GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
#include "gtkdragdest.h"
#include "gtkdragsource.h"
#include "gtkgesturelongpress.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturesingle.h"
#include "gtkicontheme.h"
#include "gtkimage.h"
}
static void
-tap_action (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkColorSwatch *swatch)
+tap_action (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkColorSwatch *swatch)
{
GtkColorSwatchPrivate *priv = gtk_color_swatch_get_instance_private (swatch);
guint button;
G_CALLBACK (hold_action), swatch);
gtk_widget_add_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (gesture));
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
g_signal_connect (gesture, "pressed",
G_CALLBACK (tap_action), swatch);
#include "gtkstack.h"
#include "gtklabel.h"
#include "gtkgesturelongpress.h"
-#include "gtkgesturemultipress.h"
#include "gtkpopover.h"
#include "gtkscrolledwindow.h"
#include "gtkintl.h"
#include "gtkemojicompletion.h"
#include "gtkentrybuffer.h"
#include "gtkgesturedrag.h"
-#include "gtkgesturemultipress.h"
#include "gtkimageprivate.h"
#include "gtkimcontextsimple.h"
#include "gtkintl.h"
#include "gtkwidgetprivate.h"
#include "gtkwindow.h"
#include "gtknative.h"
+#include "gtkgestureclick.h"
#include "a11y/gtkentryaccessible.h"
}
static void
-icon_pressed_cb (GtkGestureMultiPress *gesture,
+icon_pressed_cb (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
}
static void
-icon_released_cb (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkEntry *entry)
+icon_released_cb (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkEntry *entry)
{
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
GtkEntryIconPosition pos;
update_icon_style (widget, icon_pos);
update_node_ordering (entry);
- press = gtk_gesture_multi_press_new ();
- g_signal_connect (press, "pressed",
- G_CALLBACK (icon_pressed_cb), entry);
- g_signal_connect (press, "released",
- G_CALLBACK (icon_released_cb), entry);
+ press = gtk_gesture_click_new ();
+ g_signal_connect (press, "pressed", G_CALLBACK (icon_pressed_cb), entry);
+ g_signal_connect (press, "released", G_CALLBACK (icon_released_cb), entry);
gtk_widget_add_controller (icon_info->widget, GTK_EVENT_CONTROLLER (press));
drag = gtk_gesture_drag_new ();
#include "gtkentry.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
-#include "gtkgesturemultipress.h"
#include "gtkeventcontrollerkey.h"
+#include "gtkgestureclick.h"
#include "gtkprivate.h"
#include "gtkwindowprivate.h"
G_CALLBACK (propagate_to_entry), completion);
gtk_widget_add_controller (priv->popup_window, controller);
- controller = GTK_EVENT_CONTROLLER (gtk_gesture_multi_press_new ());
+ controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ());
g_signal_connect_swapped (controller, "released",
G_CALLBACK (_gtk_entry_completion_popdown),
completion);
#include "gtkdnd.h"
#include "gtkdragdest.h"
#include "gtkiconprivate.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturesingle.h"
#include "gtkintl.h"
#include "gtklabel.h"
int *natural_baseline);
/* Gestures */
-static void gesture_multipress_released_cb (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkExpander *expander);
+static void gesture_click_released_cb (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkExpander *expander);
G_DEFINE_TYPE_WITH_CODE (GtkExpander, gtk_expander, GTK_TYPE_CONTAINER,
G_ADD_PRIVATE (GtkExpander)
gtk_drag_dest_set (GTK_WIDGET (expander), 0, NULL, 0);
gtk_drag_dest_set_track_motion (GTK_WIDGET (expander), TRUE);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture),
GDK_BUTTON_PRIMARY);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture),
FALSE);
g_signal_connect (gesture, "released",
- G_CALLBACK (gesture_multipress_released_cb), expander);
+ G_CALLBACK (gesture_click_released_cb), expander);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_BUBBLE);
gtk_widget_add_controller (GTK_WIDGET (priv->title_widget), GTK_EVENT_CONTROLLER (gesture));
}
static void
-gesture_multipress_released_cb (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkExpander *expander)
+gesture_click_released_cb (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkExpander *expander)
{
gtk_widget_activate (GTK_WIDGET (expander));
}
#include "gtkseparator.h"
#include "gtkmodelbutton.h"
#include "gtkgesturelongpress.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkeventcontrollerkey.h"
#include "gtkdebug.h"
#include "gtkfilechoosererrorstackprivate.h"
}
static void
-multi_press_cb (GtkGesture *gesture,
- int n_press,
- double x,
- double y,
- GtkFileChooserWidget *impl)
+click_cb (GtkGesture *gesture,
+ int n_press,
+ double x,
+ double y,
+ GtkFileChooserWidget *impl)
{
PopoverData *pd;
gtk_widget_class_bind_template_callback (widget_class, rename_file_name_changed);
gtk_widget_class_bind_template_callback (widget_class, rename_file_rename_clicked);
gtk_widget_class_bind_template_callback (widget_class, rename_file_end);
- gtk_widget_class_bind_template_callback (widget_class, multi_press_cb);
+ gtk_widget_class_bind_template_callback (widget_class, click_cb);
gtk_widget_class_bind_template_callback (widget_class, long_press_cb);
gtk_widget_class_bind_template_callback (widget_class, key_press_cb);
gtk_widget_class_bind_template_callback (widget_class, widget_key_press_cb);
#include "gtkcontainerprivate.h"
#include "gtkcssnodeprivate.h"
#include "gtkgesturedrag.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
}
static void
-gtk_flow_box_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkFlowBox *box)
+gtk_flow_box_click_gesture_pressed (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkFlowBox *box)
{
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
GtkFlowBoxChild *child;
}
static void
-gtk_flow_box_multipress_unpaired_release (GtkGestureMultiPress *gesture,
- gdouble x,
- gdouble y,
- guint button,
- GdkEventSequence *sequence,
- GtkFlowBox *box)
+gtk_flow_box_click_unpaired_release (GtkGestureClick *gesture,
+ gdouble x,
+ gdouble y,
+ guint button,
+ GdkEventSequence *sequence,
+ GtkFlowBox *box)
{
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
GtkFlowBoxChild *child;
}
static void
-gtk_flow_box_multipress_gesture_released (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkFlowBox *box)
+gtk_flow_box_click_gesture_released (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkFlowBox *box)
{
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
}
static void
-gtk_flow_box_multipress_gesture_stopped (GtkGestureMultiPress *gesture,
- GtkFlowBox *box)
+gtk_flow_box_click_gesture_stopped (GtkGestureClick *gesture,
+ GtkFlowBox *box)
{
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
priv->children = g_sequence_new (NULL);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture),
FALSE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture),
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_BUBBLE);
g_signal_connect (gesture, "pressed",
- G_CALLBACK (gtk_flow_box_multipress_gesture_pressed), box);
+ G_CALLBACK (gtk_flow_box_click_gesture_pressed), box);
g_signal_connect (gesture, "released",
- G_CALLBACK (gtk_flow_box_multipress_gesture_released), box);
+ G_CALLBACK (gtk_flow_box_click_gesture_released), box);
g_signal_connect (gesture, "stopped",
- G_CALLBACK (gtk_flow_box_multipress_gesture_stopped), box);
+ G_CALLBACK (gtk_flow_box_click_gesture_stopped), box);
g_signal_connect (gesture, "unpaired-release",
- G_CALLBACK (gtk_flow_box_multipress_unpaired_release), box);
+ G_CALLBACK (gtk_flow_box_click_unpaired_release), box);
gtk_widget_add_controller (GTK_WIDGET (box), GTK_EVENT_CONTROLLER (gesture));
priv->drag_gesture = gtk_gesture_drag_new ();
#include "gtkdialog.h"
#include "gtkradiobutton.h"
#include "gtkcombobox.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkeventcontrollerscroll.h"
#include "gtkroot.h"
g_signal_connect_swapped (feat, "notify::inconsistent", G_CALLBACK (update_font_features), fontchooser);
g_signal_connect (feat, "clicked", G_CALLBACK (feat_clicked), NULL);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed", G_CALLBACK (feat_pressed), feat);
gtk_widget_add_controller (feat, GTK_EVENT_CONTROLLER (gesture));
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2014 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author(s): Carlos Garnacho <carlosg@gnome.org>
+ */
+
+/**
+ * SECTION:gtkgestureclick
+ * @Short_description: Multipress gesture
+ * @Title: GtkGestureClick
+ *
+ * #GtkGestureClick is a #GtkGesture implementation able to recognize
+ * multiple clicks on a nearby zone, which can be listened for through
+ * the #GtkGestureClick::pressed signal. Whenever time or distance
+ * between clicks exceed the GTK+ defaults, #GtkGestureClick::stopped
+ * is emitted, and the click counter is reset.
+ *
+ * Callers may also restrict the area that is considered valid for a >1
+ * touch/button press through gtk_gesture_click_set_area(), so any
+ * click happening outside that area is considered to be a first click
+ * of its own.
+ */
+
+#include "config.h"
+#include "gtkgestureprivate.h"
+#include "gtkgestureclick.h"
+#include "gtkgestureclickprivate.h"
+#include "gtkprivate.h"
+#include "gtkintl.h"
+
+typedef struct _GtkGestureClickPrivate GtkGestureClickPrivate;
+
+struct _GtkGestureClickPrivate
+{
+ GdkRectangle rect;
+ GdkDevice *current_device;
+ gdouble initial_press_x;
+ gdouble initial_press_y;
+ guint double_click_timeout_id;
+ guint n_presses;
+ guint n_release;
+ guint current_button;
+ guint rect_is_set : 1;
+};
+
+enum {
+ PRESSED,
+ RELEASED,
+ STOPPED,
+ UNPAIRED_RELEASE,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE_WITH_PRIVATE (GtkGestureClick, gtk_gesture_click, GTK_TYPE_GESTURE_SINGLE)
+
+static void
+gtk_gesture_click_finalize (GObject *object)
+{
+ GtkGestureClickPrivate *priv;
+ GtkGestureClick *gesture;
+
+ gesture = GTK_GESTURE_CLICK (object);
+ priv = gtk_gesture_click_get_instance_private (gesture);
+
+ if (priv->double_click_timeout_id)
+ {
+ g_source_remove (priv->double_click_timeout_id);
+ priv->double_click_timeout_id = 0;
+ }
+
+ G_OBJECT_CLASS (gtk_gesture_click_parent_class)->finalize (object);
+}
+
+static gboolean
+gtk_gesture_click_check (GtkGesture *gesture)
+{
+ GtkGestureClick *click;
+ GtkGestureClickPrivate *priv;
+ GList *sequences;
+ gboolean active;
+
+ click = GTK_GESTURE_CLICK (gesture);
+ priv = gtk_gesture_click_get_instance_private (click);
+ sequences = gtk_gesture_get_sequences (gesture);
+
+ active = g_list_length (sequences) == 1 || priv->double_click_timeout_id;
+ g_list_free (sequences);
+
+ return active;
+}
+
+static void
+_gtk_gesture_click_stop (GtkGestureClick *gesture)
+{
+ GtkGestureClickPrivate *priv;
+
+ priv = gtk_gesture_click_get_instance_private (gesture);
+
+ if (priv->n_presses == 0)
+ return;
+
+ priv->current_device = NULL;
+ priv->current_button = 0;
+ priv->n_presses = 0;
+ g_signal_emit (gesture, signals[STOPPED], 0);
+ _gtk_gesture_check (GTK_GESTURE (gesture));
+}
+
+static gboolean
+_double_click_timeout_cb (gpointer user_data)
+{
+ GtkGestureClick *gesture = user_data;
+ GtkGestureClickPrivate *priv;
+
+ priv = gtk_gesture_click_get_instance_private (gesture);
+ priv->double_click_timeout_id = 0;
+ _gtk_gesture_click_stop (gesture);
+
+ return FALSE;
+}
+
+static void
+_gtk_gesture_click_update_timeout (GtkGestureClick *gesture)
+{
+ GtkGestureClickPrivate *priv;
+ guint double_click_time;
+ GtkSettings *settings;
+ GtkWidget *widget;
+
+ priv = gtk_gesture_click_get_instance_private (gesture);
+
+ if (priv->double_click_timeout_id)
+ g_source_remove (priv->double_click_timeout_id);
+
+ widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
+ settings = gtk_widget_get_settings (widget);
+ g_object_get (settings, "gtk-double-click-time", &double_click_time, NULL);
+
+ priv->double_click_timeout_id = g_timeout_add (double_click_time, _double_click_timeout_cb, gesture);
+ g_source_set_name_by_id (priv->double_click_timeout_id, "[gtk] _double_click_timeout_cb");
+}
+
+static gboolean
+_gtk_gesture_click_check_within_threshold (GtkGestureClick *gesture,
+ double x,
+ double y)
+{
+ GtkGestureClickPrivate *priv;
+ guint double_click_distance;
+ GtkSettings *settings;
+ GtkWidget *widget;
+
+ priv = gtk_gesture_click_get_instance_private (gesture);
+
+ if (priv->n_presses == 0)
+ return TRUE;
+
+ widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
+ settings = gtk_widget_get_settings (widget);
+ g_object_get (settings,
+ "gtk-double-click-distance", &double_click_distance,
+ NULL);
+
+ if (ABS (priv->initial_press_x - x) < double_click_distance &&
+ ABS (priv->initial_press_y - y) < double_click_distance)
+ {
+ if (!priv->rect_is_set ||
+ (x >= priv->rect.x && x < priv->rect.x + priv->rect.width &&
+ y >= priv->rect.y && y < priv->rect.y + priv->rect.height))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+gtk_gesture_click_begin (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ GtkGestureClick *click;
+ GtkGestureClickPrivate *priv;
+ guint n_presses, button = 1;
+ GdkEventSequence *current;
+ const GdkEvent *event;
+ GdkEventType event_type;
+ GdkDevice *device;
+ gdouble x, y;
+
+ if (!gtk_gesture_handles_sequence (gesture, sequence))
+ return;
+
+ click = GTK_GESTURE_CLICK (gesture);
+ priv = gtk_gesture_click_get_instance_private (click);
+ event = gtk_gesture_get_last_event (gesture, sequence);
+ current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
+ device = gdk_event_get_source_device (event);
+ event_type = gdk_event_get_event_type (event);
+
+ if (event_type == GDK_BUTTON_PRESS)
+ gdk_event_get_button (event, &button);
+ else if (event_type == GDK_TOUCH_BEGIN)
+ button = 1;
+ else
+ return;
+
+ /* Reset the gesture if the button number changes mid-recognition */
+ if (priv->n_presses > 0 &&
+ priv->current_button != button)
+ _gtk_gesture_click_stop (click);
+
+ /* Reset also if the device changed */
+ if (priv->current_device && priv->current_device != device)
+ _gtk_gesture_click_stop (click);
+
+ priv->current_device = device;
+ priv->current_button = button;
+ _gtk_gesture_click_update_timeout (click);
+ gtk_gesture_get_point (gesture, current, &x, &y);
+
+ if (!_gtk_gesture_click_check_within_threshold (click, x, y))
+ _gtk_gesture_click_stop (click);
+
+ /* Increment later the real counter, just if the gesture is
+ * reset on the pressed handler */
+ n_presses = priv->n_release = priv->n_presses + 1;
+
+ g_signal_emit (gesture, signals[PRESSED], 0, n_presses, x, y);
+
+ if (priv->n_presses == 0)
+ {
+ priv->initial_press_x = x;
+ priv->initial_press_y = y;
+ }
+
+ priv->n_presses++;
+}
+
+static void
+gtk_gesture_click_update (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ GtkGestureClick *click;
+ GdkEventSequence *current;
+ gdouble x, y;
+
+ click = GTK_GESTURE_CLICK (gesture);
+ current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
+ gtk_gesture_get_point (gesture, current, &x, &y);
+
+ if (!_gtk_gesture_click_check_within_threshold (click, x, y))
+ _gtk_gesture_click_stop (click);
+}
+
+static void
+gtk_gesture_click_end (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ GtkGestureClick *click;
+ GtkGestureClickPrivate *priv;
+ GdkEventSequence *current;
+ gdouble x, y;
+ gboolean interpreted;
+ GtkEventSequenceState state;
+
+ click = GTK_GESTURE_CLICK (gesture);
+ priv = gtk_gesture_click_get_instance_private (click);
+ current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
+ interpreted = gtk_gesture_get_point (gesture, current, &x, &y);
+ state = gtk_gesture_get_sequence_state (gesture, current);
+
+ if (state != GTK_EVENT_SEQUENCE_DENIED && interpreted)
+ g_signal_emit (gesture, signals[RELEASED], 0, priv->n_release, x, y);
+
+ priv->n_release = 0;
+}
+
+static void
+gtk_gesture_click_cancel (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ _gtk_gesture_click_stop (GTK_GESTURE_CLICK (gesture));
+ GTK_GESTURE_CLASS (gtk_gesture_click_parent_class)->cancel (gesture, sequence);
+}
+
+static void
+gtk_gesture_click_reset (GtkEventController *controller)
+{
+ _gtk_gesture_click_stop (GTK_GESTURE_CLICK (controller));
+ GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_click_parent_class)->reset (controller);
+}
+
+static gboolean
+gtk_gesture_click_handle_event (GtkEventController *controller,
+ const GdkEvent *event)
+{
+ GtkEventControllerClass *parent_controller;
+ GtkGestureClickPrivate *priv;
+ GdkEventSequence *sequence;
+ guint button;
+ gdouble x, y;
+
+ priv = gtk_gesture_click_get_instance_private (GTK_GESTURE_CLICK (controller));
+ parent_controller = GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_click_parent_class);
+ sequence = gdk_event_get_event_sequence (event);
+
+ if (priv->n_presses == 0 &&
+ !gtk_gesture_handles_sequence (GTK_GESTURE (controller), sequence) &&
+ (gdk_event_get_event_type (event) == GDK_BUTTON_RELEASE ||
+ gdk_event_get_event_type (event) == GDK_TOUCH_END))
+ {
+ if (!gdk_event_get_button (event, &button))
+ button = 0;
+ gdk_event_get_coords (event, &x, &y);
+ g_signal_emit (controller, signals[UNPAIRED_RELEASE], 0,
+ x, y, button, sequence);
+ }
+
+ return parent_controller->handle_event (controller, event);
+}
+
+static void
+gtk_gesture_click_class_init (GtkGestureClickClass *klass)
+{
+ GtkEventControllerClass *controller_class = GTK_EVENT_CONTROLLER_CLASS (klass);
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkGestureClass *gesture_class = GTK_GESTURE_CLASS (klass);
+
+ object_class->finalize = gtk_gesture_click_finalize;
+
+ gesture_class->check = gtk_gesture_click_check;
+ gesture_class->begin = gtk_gesture_click_begin;
+ gesture_class->update = gtk_gesture_click_update;
+ gesture_class->end = gtk_gesture_click_end;
+ gesture_class->cancel = gtk_gesture_click_cancel;
+
+ controller_class->reset = gtk_gesture_click_reset;
+ controller_class->handle_event = gtk_gesture_click_handle_event;
+
+ /**
+ * GtkGestureClick::pressed:
+ * @gesture: the object which received the signal
+ * @n_press: how many touch/button presses happened with this one
+ * @x: The X coordinate, in widget allocation coordinates
+ * @y: The Y coordinate, in widget allocation coordinates
+ *
+ * This signal is emitted whenever a button or touch press happens.
+ */
+ signals[PRESSED] =
+ g_signal_new (I_("pressed"),
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkGestureClickClass, pressed),
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 3, G_TYPE_INT,
+ G_TYPE_DOUBLE, G_TYPE_DOUBLE);
+
+ /**
+ * GtkGestureClick::released:
+ * @gesture: the object which received the signal
+ * @n_press: number of press that is paired with this release
+ * @x: The X coordinate, in widget allocation coordinates
+ * @y: The Y coordinate, in widget allocation coordinates
+ *
+ * This signal is emitted when a button or touch is released. @n_press
+ * will report the number of press that is paired to this event, note
+ * that #GtkGestureClick::stopped may have been emitted between the
+ * press and its release, @n_press will only start over at the next press.
+ */
+ signals[RELEASED] =
+ g_signal_new (I_("released"),
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkGestureClickClass, released),
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 3, G_TYPE_INT,
+ G_TYPE_DOUBLE, G_TYPE_DOUBLE);
+ /**
+ * GtkGestureClick::stopped:
+ * @gesture: the object which received the signal
+ *
+ * This signal is emitted whenever any time/distance threshold has
+ * been exceeded.
+ */
+ signals[STOPPED] =
+ g_signal_new (I_("stopped"),
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkGestureClickClass, stopped),
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 0);
+
+ /**
+ * GtkGestureClick::unpaired-release
+ * @gesture: the object which received the signal
+ * @x: X coordinate of the event
+ * @y: Y coordinate of the event
+ * @button: Button being released
+ * @sequence: Sequence being released
+ *
+ * This signal is emitted whenever the gesture receives a release
+ * event that had no previous corresponding press. Due to implicit
+ * grabs, this can only happen on situations where input is grabbed
+ * elsewhere mid-press or the pressed widget voluntarily relinquishes
+ * its implicit grab.
+ */
+ signals[UNPAIRED_RELEASE] =
+ g_signal_new (I_("unpaired-release"),
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL, NULL,
+ G_TYPE_NONE, 4,
+ G_TYPE_DOUBLE, G_TYPE_DOUBLE,
+ G_TYPE_UINT, GDK_TYPE_EVENT_SEQUENCE);
+}
+
+static void
+gtk_gesture_click_init (GtkGestureClick *gesture)
+{
+}
+
+/**
+ * gtk_gesture_click_new:
+ *
+ * Returns a newly created #GtkGesture that recognizes single and multiple
+ * presses.
+ *
+ * Returns: a newly created #GtkGestureClick
+ **/
+GtkGesture *
+gtk_gesture_click_new (void)
+{
+ return g_object_new (GTK_TYPE_GESTURE_CLICK,
+ NULL);
+}
+
+/**
+ * gtk_gesture_click_set_area:
+ * @gesture: a #GtkGestureClick
+ * @rect: (allow-none): rectangle to receive coordinates on
+ *
+ * If @rect is non-%NULL, the press area will be checked to be
+ * confined within the rectangle, otherwise the button count
+ * will be reset so the press is seen as being the first one.
+ * If @rect is %NULL, the area will be reset to an unrestricted
+ * state.
+ *
+ * Note: The rectangle is only used to determine whether any
+ * non-first click falls within the expected area. This is not
+ * akin to an input shape.
+ **/
+void
+gtk_gesture_click_set_area (GtkGestureClick *gesture,
+ const GdkRectangle *rect)
+{
+ GtkGestureClickPrivate *priv;
+
+ g_return_if_fail (GTK_IS_GESTURE_CLICK (gesture));
+
+ priv = gtk_gesture_click_get_instance_private (gesture);
+
+ if (!rect)
+ priv->rect_is_set = FALSE;
+ else
+ {
+ priv->rect_is_set = TRUE;
+ priv->rect = *rect;
+ }
+}
+
+/**
+ * gtk_gesture_click_get_area:
+ * @gesture: a #GtkGestureClick
+ * @rect: (out): return location for the press area
+ *
+ * If an area was set through gtk_gesture_click_set_area(),
+ * this function will return %TRUE and fill in @rect with the
+ * press area. See gtk_gesture_click_set_area() for more
+ * details on what the press area represents.
+ *
+ * Returns: %TRUE if @rect was filled with the press area
+ **/
+gboolean
+gtk_gesture_click_get_area (GtkGestureClick *gesture,
+ GdkRectangle *rect)
+{
+ GtkGestureClickPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_GESTURE_CLICK (gesture), FALSE);
+
+ priv = gtk_gesture_click_get_instance_private (gesture);
+
+ if (rect)
+ {
+ if (priv->rect_is_set)
+ *rect = priv->rect;
+ else
+ {
+ rect->x = rect->y = G_MININT;
+ rect->width = rect->height = G_MAXINT;
+ }
+ }
+
+ return priv->rect_is_set;
+}
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2014 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author(s): Carlos Garnacho <carlosg@gnome.org>
+ */
+#ifndef __GTK_GESTURE_CLICK_H__
+#define __GTK_GESTURE_CLICK_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtkwidget.h>
+#include <gtk/gtkgesturesingle.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_GESTURE_CLICK (gtk_gesture_click_get_type ())
+#define GTK_GESTURE_CLICK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_CLICK, GtkGestureClick))
+#define GTK_GESTURE_CLICK_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_CLICK, GtkGestureClickClass))
+#define GTK_IS_GESTURE_CLICK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_CLICK))
+#define GTK_IS_GESTURE_CLICK_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_CLICK))
+#define GTK_GESTURE_CLICK_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_CLICK, GtkGestureClickClass))
+
+typedef struct _GtkGestureClick GtkGestureClick;
+typedef struct _GtkGestureClickClass GtkGestureClickClass;
+
+GDK_AVAILABLE_IN_ALL
+GType gtk_gesture_click_get_type (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_ALL
+GtkGesture * gtk_gesture_click_new (void);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_gesture_click_set_area (GtkGestureClick *gesture,
+ const GdkRectangle *rect);
+GDK_AVAILABLE_IN_ALL
+gboolean gtk_gesture_click_get_area (GtkGestureClick *gesture,
+ GdkRectangle *rect);
+
+G_END_DECLS
+
+#endif /* __GTK_GESTURE_CLICK_H__ */
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2014 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author(s): Carlos Garnacho <carlosg@gnome.org>
+ */
+#ifndef __GTK_GESTURE_CLICK_PRIVATE_H__
+#define __GTK_GESTURE_CLICK_PRIVATE_H__
+
+#include "gtkgesturesingleprivate.h"
+#include "gtkgestureclick.h"
+
+struct _GtkGestureClick
+{
+ GtkGestureSingle parent_instance;
+};
+
+struct _GtkGestureClickClass
+{
+ GtkGestureSingleClass parent_class;
+
+ void (* pressed) (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y);
+ void (* released) (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y);
+ void (* stopped) (GtkGestureClick *gesture);
+
+ /*<private>*/
+ gpointer padding[10];
+};
+
+#endif /* __GTK_GESTURE_CLICK_PRIVATE_H__ */
+++ /dev/null
-/* GTK - The GIMP Toolkit
- * Copyright (C) 2014 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author(s): Carlos Garnacho <carlosg@gnome.org>
- */
-
-/**
- * SECTION:gtkgesturemultipress
- * @Short_description: Multipress gesture
- * @Title: GtkGestureMultiPress
- *
- * #GtkGestureMultiPress is a #GtkGesture implementation able to recognize
- * multiple clicks on a nearby zone, which can be listened for through the
- * #GtkGestureMultiPress::pressed signal. Whenever time or distance between
- * clicks exceed the GTK+ defaults, #GtkGestureMultiPress::stopped is emitted,
- * and the click counter is reset.
- *
- * Callers may also restrict the area that is considered valid for a >1
- * touch/button press through gtk_gesture_multi_press_set_area(), so any
- * click happening outside that area is considered to be a first click of
- * its own.
- */
-
-#include "config.h"
-#include "gtkgestureprivate.h"
-#include "gtkgesturemultipress.h"
-#include "gtkgesturemultipressprivate.h"
-#include "gtkprivate.h"
-#include "gtkintl.h"
-
-typedef struct _GtkGestureMultiPressPrivate GtkGestureMultiPressPrivate;
-
-struct _GtkGestureMultiPressPrivate
-{
- GdkRectangle rect;
- GdkDevice *current_device;
- gdouble initial_press_x;
- gdouble initial_press_y;
- guint double_click_timeout_id;
- guint n_presses;
- guint n_release;
- guint current_button;
- guint rect_is_set : 1;
-};
-
-enum {
- PRESSED,
- RELEASED,
- STOPPED,
- UNPAIRED_RELEASE,
- LAST_SIGNAL
-};
-
-static guint signals[LAST_SIGNAL] = { 0 };
-
-G_DEFINE_TYPE_WITH_PRIVATE (GtkGestureMultiPress, gtk_gesture_multi_press, GTK_TYPE_GESTURE_SINGLE)
-
-static void
-gtk_gesture_multi_press_finalize (GObject *object)
-{
- GtkGestureMultiPressPrivate *priv;
- GtkGestureMultiPress *gesture;
-
- gesture = GTK_GESTURE_MULTI_PRESS (object);
- priv = gtk_gesture_multi_press_get_instance_private (gesture);
-
- if (priv->double_click_timeout_id)
- {
- g_source_remove (priv->double_click_timeout_id);
- priv->double_click_timeout_id = 0;
- }
-
- G_OBJECT_CLASS (gtk_gesture_multi_press_parent_class)->finalize (object);
-}
-
-static gboolean
-gtk_gesture_multi_press_check (GtkGesture *gesture)
-{
- GtkGestureMultiPress *multi_press;
- GtkGestureMultiPressPrivate *priv;
- GList *sequences;
- gboolean active;
-
- multi_press = GTK_GESTURE_MULTI_PRESS (gesture);
- priv = gtk_gesture_multi_press_get_instance_private (multi_press);
- sequences = gtk_gesture_get_sequences (gesture);
-
- active = g_list_length (sequences) == 1 || priv->double_click_timeout_id;
- g_list_free (sequences);
-
- return active;
-}
-
-static void
-_gtk_gesture_multi_press_stop (GtkGestureMultiPress *gesture)
-{
- GtkGestureMultiPressPrivate *priv;
-
- priv = gtk_gesture_multi_press_get_instance_private (gesture);
-
- if (priv->n_presses == 0)
- return;
-
- priv->current_device = NULL;
- priv->current_button = 0;
- priv->n_presses = 0;
- g_signal_emit (gesture, signals[STOPPED], 0);
- _gtk_gesture_check (GTK_GESTURE (gesture));
-}
-
-static gboolean
-_double_click_timeout_cb (gpointer user_data)
-{
- GtkGestureMultiPress *gesture = user_data;
- GtkGestureMultiPressPrivate *priv;
-
- priv = gtk_gesture_multi_press_get_instance_private (gesture);
- priv->double_click_timeout_id = 0;
- _gtk_gesture_multi_press_stop (gesture);
-
- return FALSE;
-}
-
-static void
-_gtk_gesture_multi_press_update_timeout (GtkGestureMultiPress *gesture)
-{
- GtkGestureMultiPressPrivate *priv;
- guint double_click_time;
- GtkSettings *settings;
- GtkWidget *widget;
-
- priv = gtk_gesture_multi_press_get_instance_private (gesture);
-
- if (priv->double_click_timeout_id)
- g_source_remove (priv->double_click_timeout_id);
-
- widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
- settings = gtk_widget_get_settings (widget);
- g_object_get (settings, "gtk-double-click-time", &double_click_time, NULL);
-
- priv->double_click_timeout_id = g_timeout_add (double_click_time, _double_click_timeout_cb, gesture);
- g_source_set_name_by_id (priv->double_click_timeout_id, "[gtk] _double_click_timeout_cb");
-}
-
-static gboolean
-_gtk_gesture_multi_press_check_within_threshold (GtkGestureMultiPress *gesture,
- gdouble x,
- gdouble y)
-{
- GtkGestureMultiPressPrivate *priv;
- guint double_click_distance;
- GtkSettings *settings;
- GtkWidget *widget;
-
- priv = gtk_gesture_multi_press_get_instance_private (gesture);
-
- if (priv->n_presses == 0)
- return TRUE;
-
- widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
- settings = gtk_widget_get_settings (widget);
- g_object_get (settings,
- "gtk-double-click-distance", &double_click_distance,
- NULL);
-
- if (ABS (priv->initial_press_x - x) < double_click_distance &&
- ABS (priv->initial_press_y - y) < double_click_distance)
- {
- if (!priv->rect_is_set ||
- (x >= priv->rect.x && x < priv->rect.x + priv->rect.width &&
- y >= priv->rect.y && y < priv->rect.y + priv->rect.height))
- return TRUE;
- }
-
- return FALSE;
-}
-
-static void
-gtk_gesture_multi_press_begin (GtkGesture *gesture,
- GdkEventSequence *sequence)
-{
- GtkGestureMultiPress *multi_press;
- GtkGestureMultiPressPrivate *priv;
- guint n_presses, button = 1;
- GdkEventSequence *current;
- const GdkEvent *event;
- GdkEventType event_type;
- GdkDevice *device;
- gdouble x, y;
-
- if (!gtk_gesture_handles_sequence (gesture, sequence))
- return;
-
- multi_press = GTK_GESTURE_MULTI_PRESS (gesture);
- priv = gtk_gesture_multi_press_get_instance_private (multi_press);
- event = gtk_gesture_get_last_event (gesture, sequence);
- current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
- device = gdk_event_get_source_device (event);
- event_type = gdk_event_get_event_type (event);
-
- if (event_type == GDK_BUTTON_PRESS)
- gdk_event_get_button (event, &button);
- else if (event_type == GDK_TOUCH_BEGIN)
- button = 1;
- else
- return;
-
- /* Reset the gesture if the button number changes mid-recognition */
- if (priv->n_presses > 0 &&
- priv->current_button != button)
- _gtk_gesture_multi_press_stop (multi_press);
-
- /* Reset also if the device changed */
- if (priv->current_device && priv->current_device != device)
- _gtk_gesture_multi_press_stop (multi_press);
-
- priv->current_device = device;
- priv->current_button = button;
- _gtk_gesture_multi_press_update_timeout (multi_press);
- gtk_gesture_get_point (gesture, current, &x, &y);
-
- if (!_gtk_gesture_multi_press_check_within_threshold (multi_press, x, y))
- _gtk_gesture_multi_press_stop (multi_press);
-
- /* Increment later the real counter, just if the gesture is
- * reset on the pressed handler */
- n_presses = priv->n_release = priv->n_presses + 1;
-
- g_signal_emit (gesture, signals[PRESSED], 0, n_presses, x, y);
-
- if (priv->n_presses == 0)
- {
- priv->initial_press_x = x;
- priv->initial_press_y = y;
- }
-
- priv->n_presses++;
-}
-
-static void
-gtk_gesture_multi_press_update (GtkGesture *gesture,
- GdkEventSequence *sequence)
-{
- GtkGestureMultiPress *multi_press;
- GdkEventSequence *current;
- gdouble x, y;
-
- multi_press = GTK_GESTURE_MULTI_PRESS (gesture);
- current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
- gtk_gesture_get_point (gesture, current, &x, &y);
-
- if (!_gtk_gesture_multi_press_check_within_threshold (multi_press, x, y))
- _gtk_gesture_multi_press_stop (multi_press);
-}
-
-static void
-gtk_gesture_multi_press_end (GtkGesture *gesture,
- GdkEventSequence *sequence)
-{
- GtkGestureMultiPress *multi_press;
- GtkGestureMultiPressPrivate *priv;
- GdkEventSequence *current;
- gdouble x, y;
- gboolean interpreted;
- GtkEventSequenceState state;
-
- multi_press = GTK_GESTURE_MULTI_PRESS (gesture);
- priv = gtk_gesture_multi_press_get_instance_private (multi_press);
- current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
- interpreted = gtk_gesture_get_point (gesture, current, &x, &y);
- state = gtk_gesture_get_sequence_state (gesture, current);
-
- if (state != GTK_EVENT_SEQUENCE_DENIED && interpreted)
- g_signal_emit (gesture, signals[RELEASED], 0, priv->n_release, x, y);
-
- priv->n_release = 0;
-}
-
-static void
-gtk_gesture_multi_press_cancel (GtkGesture *gesture,
- GdkEventSequence *sequence)
-{
- _gtk_gesture_multi_press_stop (GTK_GESTURE_MULTI_PRESS (gesture));
- GTK_GESTURE_CLASS (gtk_gesture_multi_press_parent_class)->cancel (gesture, sequence);
-}
-
-static void
-gtk_gesture_multi_press_reset (GtkEventController *controller)
-{
- _gtk_gesture_multi_press_stop (GTK_GESTURE_MULTI_PRESS (controller));
- GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_multi_press_parent_class)->reset (controller);
-}
-
-static gboolean
-gtk_gesture_multi_press_handle_event (GtkEventController *controller,
- const GdkEvent *event)
-{
- GtkEventControllerClass *parent_controller;
- GtkGestureMultiPressPrivate *priv;
- GdkEventSequence *sequence;
- guint button;
- gdouble x, y;
-
- priv = gtk_gesture_multi_press_get_instance_private (GTK_GESTURE_MULTI_PRESS (controller));
- parent_controller = GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_multi_press_parent_class);
- sequence = gdk_event_get_event_sequence (event);
-
- if (priv->n_presses == 0 &&
- !gtk_gesture_handles_sequence (GTK_GESTURE (controller), sequence) &&
- (gdk_event_get_event_type (event) == GDK_BUTTON_RELEASE ||
- gdk_event_get_event_type (event) == GDK_TOUCH_END))
- {
- if (!gdk_event_get_button (event, &button))
- button = 0;
- gdk_event_get_coords (event, &x, &y);
- g_signal_emit (controller, signals[UNPAIRED_RELEASE], 0,
- x, y, button, sequence);
- }
-
- return parent_controller->handle_event (controller, event);
-}
-
-static void
-gtk_gesture_multi_press_class_init (GtkGestureMultiPressClass *klass)
-{
- GtkEventControllerClass *controller_class = GTK_EVENT_CONTROLLER_CLASS (klass);
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GtkGestureClass *gesture_class = GTK_GESTURE_CLASS (klass);
-
- object_class->finalize = gtk_gesture_multi_press_finalize;
-
- gesture_class->check = gtk_gesture_multi_press_check;
- gesture_class->begin = gtk_gesture_multi_press_begin;
- gesture_class->update = gtk_gesture_multi_press_update;
- gesture_class->end = gtk_gesture_multi_press_end;
- gesture_class->cancel = gtk_gesture_multi_press_cancel;
-
- controller_class->reset = gtk_gesture_multi_press_reset;
- controller_class->handle_event = gtk_gesture_multi_press_handle_event;
-
- /**
- * GtkGestureMultiPress::pressed:
- * @gesture: the object which received the signal
- * @n_press: how many touch/button presses happened with this one
- * @x: The X coordinate, in widget allocation coordinates
- * @y: The Y coordinate, in widget allocation coordinates
- *
- * This signal is emitted whenever a button or touch press happens.
- */
- signals[PRESSED] =
- g_signal_new (I_("pressed"),
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkGestureMultiPressClass, pressed),
- NULL, NULL, NULL,
- G_TYPE_NONE, 3, G_TYPE_INT,
- G_TYPE_DOUBLE, G_TYPE_DOUBLE);
-
- /**
- * GtkGestureMultiPress::released:
- * @gesture: the object which received the signal
- * @n_press: number of press that is paired with this release
- * @x: The X coordinate, in widget allocation coordinates
- * @y: The Y coordinate, in widget allocation coordinates
- *
- * This signal is emitted when a button or touch is released. @n_press
- * will report the number of press that is paired to this event, note
- * that #GtkGestureMultiPress::stopped may have been emitted between the
- * press and its release, @n_press will only start over at the next press.
- */
- signals[RELEASED] =
- g_signal_new (I_("released"),
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkGestureMultiPressClass, released),
- NULL, NULL, NULL,
- G_TYPE_NONE, 3, G_TYPE_INT,
- G_TYPE_DOUBLE, G_TYPE_DOUBLE);
- /**
- * GtkGestureMultiPress::stopped:
- * @gesture: the object which received the signal
- *
- * This signal is emitted whenever any time/distance threshold has
- * been exceeded.
- */
- signals[STOPPED] =
- g_signal_new (I_("stopped"),
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkGestureMultiPressClass, stopped),
- NULL, NULL, NULL,
- G_TYPE_NONE, 0);
-
- /**
- * GtkGestureMultiPress::unpaired-release
- * @gesture: the object which received the signal
- * @x: X coordinate of the event
- * @y: Y coordinate of the event
- * @button: Button being released
- * @sequence: Sequence being released
- *
- * This signal is emitted whenever the gesture receives a release
- * event that had no previous corresponding press. Due to implicit
- * grabs, this can only happen on situations where input is grabbed
- * elsewhere mid-press or the pressed widget voluntarily relinquishes
- * its implicit grab.
- */
- signals[UNPAIRED_RELEASE] =
- g_signal_new (I_("unpaired-release"),
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- 0, NULL, NULL, NULL,
- G_TYPE_NONE, 4,
- G_TYPE_DOUBLE, G_TYPE_DOUBLE,
- G_TYPE_UINT, GDK_TYPE_EVENT_SEQUENCE);
-}
-
-static void
-gtk_gesture_multi_press_init (GtkGestureMultiPress *gesture)
-{
-}
-
-/**
- * gtk_gesture_multi_press_new:
- *
- * Returns a newly created #GtkGesture that recognizes single and multiple
- * presses.
- *
- * Returns: a newly created #GtkGestureMultiPress
- **/
-GtkGesture *
-gtk_gesture_multi_press_new (void)
-{
- return g_object_new (GTK_TYPE_GESTURE_MULTI_PRESS,
- NULL);
-}
-
-/**
- * gtk_gesture_multi_press_set_area:
- * @gesture: a #GtkGestureMultiPress
- * @rect: (allow-none): rectangle to receive coordinates on
- *
- * If @rect is non-%NULL, the press area will be checked to be
- * confined within the rectangle, otherwise the button count
- * will be reset so the press is seen as being the first one.
- * If @rect is %NULL, the area will be reset to an unrestricted
- * state.
- *
- * Note: The rectangle is only used to determine whether any
- * non-first click falls within the expected area. This is not
- * akin to an input shape.
- **/
-void
-gtk_gesture_multi_press_set_area (GtkGestureMultiPress *gesture,
- const GdkRectangle *rect)
-{
- GtkGestureMultiPressPrivate *priv;
-
- g_return_if_fail (GTK_IS_GESTURE_MULTI_PRESS (gesture));
-
- priv = gtk_gesture_multi_press_get_instance_private (gesture);
-
- if (!rect)
- priv->rect_is_set = FALSE;
- else
- {
- priv->rect_is_set = TRUE;
- priv->rect = *rect;
- }
-}
-
-/**
- * gtk_gesture_multi_press_get_area:
- * @gesture: a #GtkGestureMultiPress
- * @rect: (out): return location for the press area
- *
- * If an area was set through gtk_gesture_multi_press_set_area(),
- * this function will return %TRUE and fill in @rect with the
- * press area. See gtk_gesture_multi_press_set_area() for more
- * details on what the press area represents.
- *
- * Returns: %TRUE if @rect was filled with the press area
- **/
-gboolean
-gtk_gesture_multi_press_get_area (GtkGestureMultiPress *gesture,
- GdkRectangle *rect)
-{
- GtkGestureMultiPressPrivate *priv;
-
- g_return_val_if_fail (GTK_IS_GESTURE_MULTI_PRESS (gesture), FALSE);
-
- priv = gtk_gesture_multi_press_get_instance_private (gesture);
-
- if (rect)
- {
- if (priv->rect_is_set)
- *rect = priv->rect;
- else
- {
- rect->x = rect->y = G_MININT;
- rect->width = rect->height = G_MAXINT;
- }
- }
-
- return priv->rect_is_set;
-}
+++ /dev/null
-/* GTK - The GIMP Toolkit
- * Copyright (C) 2014 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author(s): Carlos Garnacho <carlosg@gnome.org>
- */
-#ifndef __GTK_GESTURE_MULTI_PRESS_H__
-#define __GTK_GESTURE_MULTI_PRESS_H__
-
-#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gtk/gtk.h> can be included directly."
-#endif
-
-#include <gtk/gtkwidget.h>
-#include <gtk/gtkgesturesingle.h>
-
-G_BEGIN_DECLS
-
-#define GTK_TYPE_GESTURE_MULTI_PRESS (gtk_gesture_multi_press_get_type ())
-#define GTK_GESTURE_MULTI_PRESS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_MULTI_PRESS, GtkGestureMultiPress))
-#define GTK_GESTURE_MULTI_PRESS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_MULTI_PRESS, GtkGestureMultiPressClass))
-#define GTK_IS_GESTURE_MULTI_PRESS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_MULTI_PRESS))
-#define GTK_IS_GESTURE_MULTI_PRESS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_MULTI_PRESS))
-#define GTK_GESTURE_MULTI_PRESS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_MULTI_PRESS, GtkGestureMultiPressClass))
-
-typedef struct _GtkGestureMultiPress GtkGestureMultiPress;
-typedef struct _GtkGestureMultiPressClass GtkGestureMultiPressClass;
-
-GDK_AVAILABLE_IN_ALL
-GType gtk_gesture_multi_press_get_type (void) G_GNUC_CONST;
-
-GDK_AVAILABLE_IN_ALL
-GtkGesture * gtk_gesture_multi_press_new (void);
-
-GDK_AVAILABLE_IN_ALL
-void gtk_gesture_multi_press_set_area (GtkGestureMultiPress *gesture,
- const GdkRectangle *rect);
-GDK_AVAILABLE_IN_ALL
-gboolean gtk_gesture_multi_press_get_area (GtkGestureMultiPress *gesture,
- GdkRectangle *rect);
-
-G_END_DECLS
-
-#endif /* __GTK_GESTURE_MULTI_PRESS_H__ */
+++ /dev/null
-/* GTK - The GIMP Toolkit
- * Copyright (C) 2014 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author(s): Carlos Garnacho <carlosg@gnome.org>
- */
-#ifndef __GTK_GESTURE_MULTI_PRESS_PRIVATE_H__
-#define __GTK_GESTURE_MULTI_PRESS_PRIVATE_H__
-
-#include "gtkgesturesingleprivate.h"
-#include "gtkgesturemultipress.h"
-
-struct _GtkGestureMultiPress
-{
- GtkGestureSingle parent_instance;
-};
-
-struct _GtkGestureMultiPressClass
-{
- GtkGestureSingleClass parent_class;
-
- void (* pressed) (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y);
- void (* released) (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y);
- void (* stopped) (GtkGestureMultiPress *gesture);
-
- /*<private>*/
- gpointer padding[10];
-};
-
-#endif /* __GTK_GESTURE_MULTI_PRESS_PRIVATE_H__ */
GdkCrossingMode mode,
GdkNotifyType detail,
gpointer user_data);
-static void gtk_icon_view_button_press (GtkGestureMultiPress *gesture,
+static void gtk_icon_view_button_press (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gpointer user_data);
-static void gtk_icon_view_button_release (GtkGestureMultiPress *gesture,
+static void gtk_icon_view_button_release (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (icon_view)),
GTK_STYLE_CLASS_VIEW);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (gtk_icon_view_button_press),
icon_view);
g_signal_connect (gesture, "released", G_CALLBACK (gtk_icon_view_button_release),
}
static void
-gtk_icon_view_button_press (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_icon_view_button_press (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkIconView *icon_view = user_data;
GtkWidget *widget = GTK_WIDGET (icon_view);
}
static void
-gtk_icon_view_button_release (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_icon_view_button_release (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkIconView *icon_view = user_data;
int button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
#include "gtk/gtkiconview.h"
#include "gtk/gtkcssnodeprivate.h"
-#include "gtk/gtkgesturemultipress.h"
+#include "gtk/gtkgestureclick.h"
#include "gtk/gtkeventcontrollermotion.h"
#ifndef __GTK_ICON_VIEW_PRIVATE_H__
}
static void
-pressed_cb (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkIMContextWayland *context)
+pressed_cb (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkIMContextWayland *context)
{
if (n_press == 1)
{
}
static void
-released_cb (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkIMContextWayland *context)
+released_cb (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkIMContextWayland *context)
{
GtkIMContextWaylandGlobal *global;
GtkInputHints hints;
{
GtkGesture *gesture;
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_CAPTURE);
g_signal_connect (gesture, "pressed",
#include "gtkdnd.h"
#include "gtkeventcontrollermotion.h"
#include "gtkgesturedrag.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturesingle.h"
#include "gtkimage.h"
#include "gtkintl.h"
GtkLabelLink *active_link;
GtkGesture *drag_gesture;
- GtkGesture *multipress_gesture;
+ GtkGesture *click_gesture;
GtkEventController *motion_controller;
gint drag_start_x;
GtkLabelLink *link);
/* Event controller callbacks */
-static void gtk_label_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+static void gtk_label_click_gesture_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkLabel *label);
-static void gtk_label_multipress_gesture_released (GtkGestureMultiPress *gesture,
+static void gtk_label_click_gesture_released (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
}
static void
-gtk_label_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble widget_x,
- gdouble widget_y,
- GtkLabel *label)
+gtk_label_click_gesture_pressed (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble widget_x,
+ gdouble widget_y,
+ GtkLabel *label)
{
GtkLabelPrivate *priv = gtk_label_get_instance_private (label);
GtkLabelSelectionInfo *info = priv->select_info;
}
static void
-gtk_label_multipress_gesture_released (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkLabel *label)
+gtk_label_click_gesture_released (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkLabel *label)
{
GtkLabelPrivate *priv = gtk_label_get_instance_private (label);
GtkLabelSelectionInfo *info = priv->select_info;
}
static void
-drag_begin_cb (GtkWidget *widget,
- GdkDrag *drag,
- gpointer data)
+drag_begin_cb (GtkWidget *widget,
+ GdkDrag *drag,
+ gpointer data)
{
GtkLabel *label = GTK_LABEL (widget);
GtkLabelPrivate *priv = gtk_label_get_instance_private (label);
gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->select_info->drag_gesture), TRUE);
gtk_widget_add_controller (GTK_WIDGET (label), GTK_EVENT_CONTROLLER (priv->select_info->drag_gesture));
- priv->select_info->multipress_gesture = gtk_gesture_multi_press_new ();
- g_signal_connect (priv->select_info->multipress_gesture, "pressed",
- G_CALLBACK (gtk_label_multipress_gesture_pressed), label);
- g_signal_connect (priv->select_info->multipress_gesture, "released",
- G_CALLBACK (gtk_label_multipress_gesture_released), label);
- gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->select_info->multipress_gesture), 0);
- gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->select_info->multipress_gesture), TRUE);
- gtk_widget_add_controller (GTK_WIDGET (label), GTK_EVENT_CONTROLLER (priv->select_info->multipress_gesture));
+ priv->select_info->click_gesture = gtk_gesture_click_new ();
+ g_signal_connect (priv->select_info->click_gesture, "pressed",
+ G_CALLBACK (gtk_label_click_gesture_pressed), label);
+ g_signal_connect (priv->select_info->click_gesture, "released",
+ G_CALLBACK (gtk_label_click_gesture_released), label);
+ gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->select_info->click_gesture), 0);
+ gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->select_info->click_gesture), TRUE);
+ gtk_widget_add_controller (GTK_WIDGET (label), GTK_EVENT_CONTROLLER (priv->select_info->click_gesture));
priv->select_info->motion_controller = gtk_event_controller_motion_new ();
g_signal_connect (priv->select_info->motion_controller, "motion",
if (!priv->select_info->selectable && !priv->select_info->links)
{
gtk_widget_remove_controller (GTK_WIDGET (label), GTK_EVENT_CONTROLLER (priv->select_info->drag_gesture));
- gtk_widget_remove_controller (GTK_WIDGET (label), GTK_EVENT_CONTROLLER (priv->select_info->multipress_gesture));
+ gtk_widget_remove_controller (GTK_WIDGET (label), GTK_EVENT_CONTROLLER (priv->select_info->click_gesture));
gtk_widget_remove_controller (GTK_WIDGET (label), priv->select_info->motion_controller);
GTK_LABEL_CONTENT (priv->select_info->provider)->label = NULL;
g_object_unref (priv->select_info->provider);
#include "gtklinkbutton.h"
#include "gtkdragsource.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturesingle.h"
#include "gtkintl.h"
#include "gtklabel.h"
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data);
-static void gtk_link_button_pressed_cb (GtkGestureMultiPress *gesture,
+static void gtk_link_button_pressed_cb (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gdk_content_formats_unref (targets);
gtk_drag_source_set_icon_name (GTK_WIDGET (link_button), "text-x-generic");
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), GTK_PHASE_BUBBLE);
}
static void
-gtk_link_button_pressed_cb (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_link_button_pressed_cb (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkLinkButton *link_button = user_data;
GtkLinkButtonPrivate *priv = gtk_link_button_get_instance_private (link_button);
#include "gtkcontainerprivate.h"
#include "gtkcssnodeprivate.h"
#include "gtkdnd.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
static void gtk_list_box_set_accept_unpaired_release (GtkListBox *box,
gboolean accept);
-static void gtk_list_box_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkListBox *box);
-static void gtk_list_box_multipress_gesture_released (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkListBox *box);
-static void gtk_list_box_multipress_unpaired_release (GtkGestureMultiPress *gesture,
- gdouble x,
- gdouble y,
- guint button,
- GdkEventSequence *sequence,
- GtkListBox *box);
-static void gtk_list_box_multipress_gesture_stopped (GtkGestureMultiPress *gesture,
- GtkListBox *box);
+static void gtk_list_box_click_gesture_pressed (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkListBox *box);
+static void gtk_list_box_click_gesture_released (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkListBox *box);
+static void gtk_list_box_click_unpaired_release (GtkGestureClick *gesture,
+ gdouble x,
+ gdouble y,
+ guint button,
+ GdkEventSequence *sequence,
+ GtkListBox *box);
+static void gtk_list_box_click_gesture_stopped (GtkGestureClick *gesture,
+ GtkListBox *box);
static void gtk_list_box_update_row_styles (GtkListBox *box);
static void gtk_list_box_update_row_style (GtkListBox *box,
priv->children = g_sequence_new (NULL);
priv->header_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_BUBBLE);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture),
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture),
GDK_BUTTON_PRIMARY);
g_signal_connect (gesture, "pressed",
- G_CALLBACK (gtk_list_box_multipress_gesture_pressed), box);
+ G_CALLBACK (gtk_list_box_click_gesture_pressed), box);
g_signal_connect (gesture, "released",
- G_CALLBACK (gtk_list_box_multipress_gesture_released), box);
+ G_CALLBACK (gtk_list_box_click_gesture_released), box);
g_signal_connect (gesture, "stopped",
- G_CALLBACK (gtk_list_box_multipress_gesture_stopped), box);
+ G_CALLBACK (gtk_list_box_click_gesture_stopped), box);
g_signal_connect (gesture, "unpaired-release",
- G_CALLBACK (gtk_list_box_multipress_unpaired_release), box);
+ G_CALLBACK (gtk_list_box_click_unpaired_release), box);
gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture));
g_signal_connect (box, "notify::parent", G_CALLBACK (gtk_list_box_parent_cb), NULL);
}
static void
-gtk_list_box_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkListBox *box)
+gtk_list_box_click_gesture_pressed (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkListBox *box)
{
GtkListBoxPrivate *priv = BOX_PRIV (box);
GtkListBoxRow *row;
}
static void
-gtk_list_box_multipress_unpaired_release (GtkGestureMultiPress *gesture,
- gdouble x,
- gdouble y,
- guint button,
- GdkEventSequence *sequence,
- GtkListBox *box)
+gtk_list_box_click_unpaired_release (GtkGestureClick *gesture,
+ gdouble x,
+ gdouble y,
+ guint button,
+ GdkEventSequence *sequence,
+ GtkListBox *box)
{
GtkListBoxPrivate *priv = BOX_PRIV (box);
GtkListBoxRow *row;
}
static void
-gtk_list_box_multipress_gesture_released (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkListBox *box)
+gtk_list_box_click_gesture_released (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkListBox *box)
{
GtkListBoxPrivate *priv = BOX_PRIV (box);
}
static void
-gtk_list_box_multipress_gesture_stopped (GtkGestureMultiPress *gesture,
+gtk_list_box_click_gesture_stopped (GtkGestureClick *gesture,
GtkListBox *box)
{
GtkListBoxPrivate *priv = BOX_PRIV (box);
*
* |[<!-- language="C" -->
* // connect our handler which will popup the menu
- * gesture = gtk_gesture_multi_press_new (window);
+ * gesture = gtk_gesture_click_new (window);
* gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture),
* GDK_BUTTON_SECONDARY);
* g_signal_connect (gesture, "begin", G_CALLBACK (my_popup_handler), menu);
int *natural,
int *minimum_baseline,
int *natural_baseline);
-static void gtk_menu_pressed_cb (GtkGestureMultiPress *gesture,
+static void gtk_menu_pressed_cb (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gpointer user_data);
-static void gtk_menu_released_cb (GtkGestureMultiPress *gesture,
+static void gtk_menu_released_cb (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gtk_widget_set_parent (priv->bottom_arrow_widget, GTK_WIDGET (menu));
gtk_widget_set_child_visible (priv->bottom_arrow_widget, FALSE);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), GTK_PHASE_BUBBLE);
static void
-gtk_menu_pressed_cb (GtkGestureMultiPress *gesture,
+gtk_menu_pressed_cb (GtkGestureClick *gesture,
int n_press,
double x,
double y,
}
static void
-gtk_menu_released_cb (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_menu_released_cb (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkMenu *menu = user_data;
GtkMenuPrivate *priv = menu->priv;
#include <gtk/gtkmenu.h>
#include <gtk/gtkcssnodeprivate.h>
-#include <gtk/gtkgesturemultipress.h>
+#include <gtk/gtkgestureclick.h>
G_BEGIN_DECLS
#include "gtkwindow.h"
#include "gtkwindowprivate.h"
#include "gtkeventcontrollerkey.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "a11y/gtkmenushellaccessible.h"
GdkModifierType modifiers,
GtkWidget *widget);
static void gtk_menu_shell_root (GtkWidget *widget);
-static void multi_press_pressed (GtkGestureMultiPress *gesture,
+static void click_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkMenuShell *menu_shell);
-static void multi_press_released (GtkGestureMultiPress *gesture,
+static void click_released (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkMenuShell *menu_shell);
-static void multi_press_stopped (GtkGestureMultiPress *gesture,
+static void click_stopped (GtkGestureClick *gesture,
GtkMenuShell *menu_shell);
G_CALLBACK (gtk_menu_shell_key_press), widget);
gtk_widget_add_controller (widget, controller);
- controller = GTK_EVENT_CONTROLLER (gtk_gesture_multi_press_new ());
+ controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ());
gtk_event_controller_set_propagation_limit (controller, GTK_LIMIT_NONE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (controller), 0);
g_signal_connect (controller, "pressed",
- G_CALLBACK (multi_press_pressed), menu_shell);
+ G_CALLBACK (click_pressed), menu_shell);
g_signal_connect (controller, "released",
- G_CALLBACK (multi_press_released), menu_shell);
+ G_CALLBACK (click_released), menu_shell);
g_signal_connect (controller, "stopped",
- G_CALLBACK (multi_press_stopped), menu_shell);
+ G_CALLBACK (click_stopped), menu_shell);
gtk_widget_add_controller (widget, controller);
}
}
static void
-multi_press_stopped (GtkGestureMultiPress *gesture,
+click_stopped (GtkGestureClick *gesture,
GtkMenuShell *menu_shell)
{
GtkMenuShellPrivate *priv = menu_shell->priv;
}
static void
-multi_press_pressed (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkMenuShell *menu_shell)
+click_pressed (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkMenuShell *menu_shell)
{
GtkMenuShellPrivate *priv = menu_shell->priv;
GtkWidget *menu_item;
}
static void
-multi_press_released (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkMenuShell *menu_shell)
+click_released (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkMenuShell *menu_shell)
{
GtkMenuShellPrivate *priv = menu_shell->priv;
GtkMenuShell *parent_shell = GTK_MENU_SHELL (priv->parent_menu_shell);
#include "gtksettings.h"
#include "gtkstylecontextprivate.h"
#include "gtkdialogprivate.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include <glib/gprintf.h>
}
static void
-multi_press_cb (GtkGesture *gesture,
+click_cb (GtkGesture *gesture,
int n_press,
double x,
double y,
G_CALLBACK (on_popup_menu_for_process_tree_view),
op);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed",
- G_CALLBACK (multi_press_cb), op);
+ G_CALLBACK (click_cb), op);
gtk_widget_add_controller (tree_view, GTK_EVENT_CONTROLLER (gesture));
list_store = gtk_list_store_new (3,
#include "gtkdnd.h"
#include "gtkdragdest.h"
#include "gtkeventcontrollermotion.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgizmoprivate.h"
#include "gtkiconprivate.h"
#include "gtkintl.h"
GObject *child,
const gchar *type);
-static void gtk_notebook_gesture_pressed (GtkGestureMultiPress *gesture,
+static void gtk_notebook_gesture_pressed (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gpointer user_data);
-static void gtk_notebook_gesture_released (GtkGestureMultiPress *gesture,
+static void gtk_notebook_gesture_released (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gtk_widget_set_vexpand (priv->stack_widget, TRUE);
gtk_container_add (GTK_CONTAINER (priv->box), priv->stack_widget);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), GTK_PHASE_CAPTURE);
g_signal_connect (gesture, "pressed", G_CALLBACK (gtk_notebook_gesture_pressed), notebook);
}
static void
-gtk_notebook_gesture_pressed (GtkGestureMultiPress *gesture,
+gtk_notebook_gesture_pressed (GtkGestureClick *gesture,
int n_press,
double x,
double y,
}
static void
-gtk_notebook_gesture_released (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_notebook_gesture_released (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkNotebook *notebook = user_data;
GtkNotebookPrivate *priv = notebook->priv;
#include "gtkbindings.h"
#include "gtktextprivate.h"
#include "gtkeditable.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkbox.h"
#include "gtkimage.h"
#include "gtkcheckmenuitem.h"
gtk_widget_set_tooltip_text (priv->peek_icon, _("Show text"));
gtk_widget_set_parent (priv->peek_icon, GTK_WIDGET (entry));
- press = gtk_gesture_multi_press_new ();
+ press = gtk_gesture_click_new ();
g_signal_connect_swapped (press, "released",
G_CALLBACK (gtk_password_entry_toggle_peek), entry);
gtk_widget_add_controller (priv->peek_icon, GTK_EVENT_CONTROLLER (press));
#include "gtkmodelbutton.h"
#include "gtkprivate.h"
#include "gtkeventcontrollerkey.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturedrag.h"
#include "gtknative.h"
GDrive *drive,
gboolean *show_unmount,
gboolean *show_eject);
-static void on_row_pressed (GtkGestureMultiPress *gesture,
+static void on_row_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkSidebarRow *row);
-static void on_row_released (GtkGestureMultiPress *gesture,
+static void on_row_released (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
g_signal_connect_swapped (eject_button, "clicked",
G_CALLBACK (eject_or_unmount_bookmark), row);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
g_signal_connect (gesture, "pressed",
G_CALLBACK (on_row_pressed), row);
}
static void
-on_row_pressed (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkSidebarRow *row)
+on_row_pressed (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkSidebarRow *row)
{
GtkPlacesSidebar *sidebar;
GtkPlacesSidebarSectionType section_type;
}
static void
-on_row_released (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkSidebarRow *row)
+on_row_released (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkSidebarRow *row)
{
GtkPlacesSidebar *sidebar;
GtkPlacesSidebarSectionType section_type;
#include "gtkeventcontrollerscroll.h"
#include "gtkgesturedrag.h"
#include "gtkgesturelongpressprivate.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgizmoprivate.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
int baseline);
static void gtk_range_unmap (GtkWidget *widget);
-static void gtk_range_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+static void gtk_range_click_gesture_pressed (GtkGestureClick *gesture,
guint n_press,
gdouble x,
gdouble y,
GtkRange *range);
-static void gtk_range_multipress_gesture_released (GtkGestureMultiPress *gesture,
+static void gtk_range_click_gesture_released (GtkGestureClick *gesture,
guint n_press,
gdouble x,
gdouble y,
/* Note: Order is important here.
* The ::drag-begin handler relies on the state set up by the
- * multipress ::pressed handler. Gestures are handling events
+ * click ::pressed handler. Gestures are handling events
* in the oppposite order in which they are added to their
* widget.
*/
G_CALLBACK (gtk_range_drag_gesture_update), range);
gtk_widget_add_controller (GTK_WIDGET (range), GTK_EVENT_CONTROLLER (priv->drag_gesture));
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
g_signal_connect (gesture, "pressed",
- G_CALLBACK (gtk_range_multipress_gesture_pressed), range);
+ G_CALLBACK (gtk_range_click_gesture_pressed), range);
g_signal_connect (gesture, "released",
- G_CALLBACK (gtk_range_multipress_gesture_released), range);
+ G_CALLBACK (gtk_range_click_gesture_released), range);
gtk_widget_add_controller (GTK_WIDGET (range), GTK_EVENT_CONTROLLER (gesture));
gtk_gesture_group (priv->drag_gesture, gesture);
}
static void
-gtk_range_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkRange *range)
+gtk_range_click_gesture_pressed (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkRange *range)
{
GtkWidget *widget = GTK_WIDGET (range);
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
}
static void
-gtk_range_multipress_gesture_released (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkRange *range)
+gtk_range_click_gesture_released (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkRange *range)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
#include "gtkbindings.h"
#include "gtkeditable.h"
#include "gtkbox.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtktextprivate.h"
#include "gtkimage.h"
#include "gtkintl.h"
}
static void
-gtk_search_entry_icon_release (GtkGestureMultiPress *press,
- int n_press,
- double x,
- double y,
- GtkSearchEntry *entry)
+gtk_search_entry_icon_release (GtkGestureClick *press,
+ int n_press,
+ double x,
+ double y,
+ GtkSearchEntry *entry)
{
GtkSearchEntryPrivate *priv = gtk_search_entry_get_instance_private (entry);
gtk_widget_set_parent (priv->icon, GTK_WIDGET (entry));
gtk_widget_set_child_visible (priv->icon, FALSE);
- press = gtk_gesture_multi_press_new ();
+ press = gtk_gesture_click_new ();
g_signal_connect (press, "released", G_CALLBACK (gtk_search_entry_icon_release), entry);
gtk_widget_add_controller (priv->icon, GTK_EVENT_CONTROLLER (press));
#include "gtkeventcontrollerkey.h"
#include "gtkeventcontrollermotion.h"
#include "gtkeventcontrollerscroll.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgestureswipe.h"
#include "gtkicontheme.h"
#include "gtkintl.h"
}
static void
-button_pressed_cb (GtkGestureMultiPress *gesture,
- int n_pressses,
- double x,
- double y,
- gpointer user_data)
+button_pressed_cb (GtkGestureClick *gesture,
+ int n_pressses,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkSpinButton *spin_button = user_data;
GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
}
static void
-button_released_cb (GtkGestureMultiPress *gesture,
- int n_pressses,
- double x,
- double y,
- gpointer user_data)
+button_released_cb (GtkGestureClick *gesture,
+ int n_pressses,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkSpinButton *spin_button = user_data;
GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
gtk_style_context_add_class (gtk_widget_get_style_context (priv->down_button), "down");
gtk_container_add (GTK_CONTAINER (priv->box), priv->down_button);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
gtk_style_context_add_class (gtk_widget_get_style_context (priv->up_button), "up");
gtk_container_add (GTK_CONTAINER (priv->box), priv->up_button);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
#include "gtkactionable.h"
#include "gtkactionhelperprivate.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturepan.h"
#include "gtkgesturesingle.h"
#include "gtkgizmoprivate.h"
GtkActionHelper *action_helper;
GtkGesture *pan_gesture;
- GtkGesture *multipress_gesture;
+ GtkGesture *click_gesture;
double handle_pos;
guint tick_id;
}
static void
-gtk_switch_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkSwitch *sw)
+gtk_switch_click_gesture_pressed (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkSwitch *sw)
{
GtkSwitchPrivate *priv = gtk_switch_get_instance_private (sw);
graphene_rect_t switch_bounds;
}
static void
-gtk_switch_multipress_gesture_released (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkSwitch *sw)
+gtk_switch_click_gesture_released (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkSwitch *sw)
{
GdkEventSequence *sequence;
*/
active = priv->handle_pos >= 0.5;
}
- else if (!gtk_gesture_handles_sequence (priv->multipress_gesture, sequence))
+ else if (!gtk_gesture_handles_sequence (priv->click_gesture, sequence))
active = priv->is_active;
else
return;
gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (gesture), TRUE);
g_signal_connect (gesture, "pressed",
- G_CALLBACK (gtk_switch_multipress_gesture_pressed), self);
+ G_CALLBACK (gtk_switch_click_gesture_pressed), self);
g_signal_connect (gesture, "released",
- G_CALLBACK (gtk_switch_multipress_gesture_released), self);
+ G_CALLBACK (gtk_switch_click_gesture_released), self);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_BUBBLE);
gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (gesture));
- priv->multipress_gesture = gesture;
+ priv->click_gesture = gesture;
gesture = gtk_gesture_pan_new (GTK_ORIENTATION_HORIZONTAL);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
#include "gtkeventcontrollerkey.h"
#include "gtkeventcontrollermotion.h"
#include "gtkgesturedrag.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturesingle.h"
#include "gtkimageprivate.h"
#include "gtkimcontextsimple.h"
double x,
double y,
GtkText *self);
-static void gtk_text_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+static void gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
int n_press,
double x,
double y,
gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->drag_gesture), TRUE);
gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (priv->drag_gesture));
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed",
- G_CALLBACK (gtk_text_multipress_gesture_pressed), self);
+ G_CALLBACK (gtk_text_click_gesture_pressed), self);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (gesture), TRUE);
gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (gesture));
}
static void
-gtk_text_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- int n_press,
- double widget_x,
- double widget_y,
- GtkText *self)
+gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
+ int n_press,
+ double widget_x,
+ double widget_y,
+ GtkText *self)
{
GtkWidget *widget = GTK_WIDGET (self);
GtkTextPrivate *priv = gtk_text_get_instance_private (self);
static void gtk_text_view_state_flags_changed (GtkWidget *widget,
GtkStateFlags previous_state);
-static void gtk_text_view_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+static void gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
priv->text_window = text_window_new (GTK_TEXT_WINDOW_TEXT, widget);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
g_signal_connect (gesture, "pressed",
- G_CALLBACK (gtk_text_view_multipress_gesture_pressed),
+ G_CALLBACK (gtk_text_view_click_gesture_pressed),
widget);
gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture));
}
static void
-gtk_text_view_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkTextView *text_view)
+gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkTextView *text_view)
{
GdkEventSequence *sequence;
GtkTextViewPrivate *priv;
#include "gtkwidgetpath.h"
#include "gtkwidgetprivate.h"
#include "gtkwindowprivate.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkbuttonprivate.h"
int *natural,
int *minimum_baseline,
int *natural_baseline);
-static void gtk_toolbar_pressed_cb (GtkGestureMultiPress *gesture,
+static void gtk_toolbar_pressed_cb (GtkGestureClick *gesture,
int n_press,
double x,
double y,
priv->timer = g_timer_new ();
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), GTK_PHASE_BUBBLE);
static void
-gtk_toolbar_pressed_cb (GtkGestureMultiPress *gesture,
- int n_press,
- double x,
- double y,
- gpointer user_data)
+gtk_toolbar_pressed_cb (GtkGestureClick *gesture,
+ int n_press,
+ double x,
+ double y,
+ gpointer user_data)
{
GtkToolbar *toolbar = user_data;
GdkEventSequence *sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
#include "gtkeventcontrollerscroll.h"
#include "gtkframe.h"
#include "gtkgesturedrag.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgesturesingle.h"
#include "gtkintl.h"
#include "gtklabel.h"
GDestroyNotify row_separator_destroy;
/* Gestures */
- GtkGesture *multipress_gesture;
+ GtkGesture *click_gesture;
GtkGesture *drag_gesture; /* Rubberbanding, row DnD */
GtkGesture *column_drag_gesture; /* Column reordering, resizing */
static void grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view);
/* Gestures */
-static void gtk_tree_view_column_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+static void gtk_tree_view_column_click_gesture_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkTreeView *tree_view);
-static void gtk_tree_view_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+static void gtk_tree_view_click_gesture_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkTreeView *tree_view);
-static void gtk_tree_view_multipress_gesture_released (GtkGestureMultiPress *gesture,
+static void gtk_tree_view_click_gesture_released (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
gtk_css_node_set_state (priv->header_node, gtk_css_node_get_state (widget_node));
g_object_unref (priv->header_node);
- priv->multipress_gesture = gtk_gesture_multi_press_new ();
- gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->multipress_gesture), 0);
- g_signal_connect (priv->multipress_gesture, "pressed",
- G_CALLBACK (gtk_tree_view_multipress_gesture_pressed), tree_view);
- g_signal_connect (priv->multipress_gesture, "released",
- G_CALLBACK (gtk_tree_view_multipress_gesture_released), tree_view);
- gtk_widget_add_controller (GTK_WIDGET (tree_view), GTK_EVENT_CONTROLLER (priv->multipress_gesture));
+ priv->click_gesture = gtk_gesture_click_new ();
+ gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->click_gesture), 0);
+ g_signal_connect (priv->click_gesture, "pressed",
+ G_CALLBACK (gtk_tree_view_click_gesture_pressed), tree_view);
+ g_signal_connect (priv->click_gesture, "released",
+ G_CALLBACK (gtk_tree_view_click_gesture_released), tree_view);
+ gtk_widget_add_controller (GTK_WIDGET (tree_view), GTK_EVENT_CONTROLLER (priv->click_gesture));
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed",
- G_CALLBACK (gtk_tree_view_column_multipress_gesture_pressed), tree_view);
+ G_CALLBACK (gtk_tree_view_column_click_gesture_pressed), tree_view);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_CAPTURE);
gtk_widget_add_controller (GTK_WIDGET (tree_view), GTK_EVENT_CONTROLLER (gesture));
}
static void
-gtk_tree_view_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+gtk_tree_view_click_gesture_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
}
static void
-gtk_tree_view_column_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
+gtk_tree_view_column_click_gesture_pressed (GtkGestureClick *gesture,
gint n_press,
gdouble x,
gdouble y,
}
static void
-gtk_tree_view_multipress_gesture_released (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkTreeView *tree_view)
+gtk_tree_view_click_gesture_released (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkTreeView *tree_view)
{
gboolean modify, extend;
guint button;
/* If we are currently pressing down a button, we don't want to prelight anything else. */
if (gtk_gesture_is_active (tree_view->priv->drag_gesture) ||
- gtk_gesture_is_active (tree_view->priv->multipress_gesture))
+ gtk_gesture_is_active (tree_view->priv->click_gesture))
node = NULL;
gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, x, y,
button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (tree_view->priv->drag_gesture));
- /* Deny the multipress gesture */
- gtk_gesture_set_state (GTK_GESTURE (tree_view->priv->multipress_gesture),
+ /* Deny the click gesture */
+ gtk_gesture_set_state (GTK_GESTURE (tree_view->priv->click_gesture),
GTK_EVENT_SEQUENCE_DENIED);
gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, start_x, start_y,
tree_view);
gtk_widget_add_controller (tree_view->priv->search_window, controller);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed",
G_CALLBACK (gtk_tree_view_search_pressed_cb), tree_view);
gtk_widget_add_controller (tree_view->priv->search_window, GTK_EVENT_CONTROLLER (gesture));
selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
/* Stop a pending double click */
- gtk_event_controller_reset (GTK_EVENT_CONTROLLER (tree_view->priv->multipress_gesture));
+ gtk_event_controller_reset (GTK_EVENT_CONTROLLER (tree_view->priv->click_gesture));
_gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
_gtk_tree_view_accessible_remove_state (tree_view,
#include "gtkeventcontrollerkey.h"
#include "gtkeventcontrollermotion.h"
#include "gtkgesturedrag.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkgestureprivate.h"
#include "gtkheaderbarprivate.h"
#include "gtkicontheme.h"
GdkSurfaceTypeHint type_hint;
- GtkGesture *multipress_gesture;
+ GtkGesture *click_gesture;
GtkGesture *drag_gesture;
GtkGesture *bubble_drag_gesture;
GtkEventController *key_controller;
}
static void
-multipress_gesture_pressed_cb (GtkGestureMultiPress *gesture,
- gint n_press,
- gdouble x,
- gdouble y,
- GtkWindow *window)
+click_gesture_pressed_cb (GtkGestureClick *gesture,
+ gint n_press,
+ gdouble x,
+ gdouble y,
+ GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWidget *event_widget, *widget;
gtk_get_current_event_time ());
gtk_event_controller_reset (GTK_EVENT_CONTROLLER (gesture));
- gtk_event_controller_reset (GTK_EVENT_CONTROLLER (priv->multipress_gesture));
+ gtk_event_controller_reset (GTK_EVENT_CONTROLLER (priv->click_gesture));
}
}
if (priv->type == GTK_WINDOW_TOPLEVEL)
{
- priv->multipress_gesture = gtk_gesture_multi_press_new ();
- gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->multipress_gesture), 0);
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->multipress_gesture),
+ priv->click_gesture = gtk_gesture_click_new ();
+ gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->click_gesture), 0);
+ gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->click_gesture),
GTK_PHASE_BUBBLE);
- g_signal_connect (priv->multipress_gesture, "pressed",
- G_CALLBACK (multipress_gesture_pressed_cb), object);
- gtk_widget_add_controller (GTK_WIDGET (object), GTK_EVENT_CONTROLLER (priv->multipress_gesture));
+ g_signal_connect (priv->click_gesture, "pressed",
+ G_CALLBACK (click_gesture_pressed_cb), object);
+ gtk_widget_add_controller (GTK_WIDGET (object), GTK_EVENT_CONTROLLER (priv->click_gesture));
priv->drag_gesture = create_drag_gesture (window);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->drag_gesture),
#include "gtkstack.h"
#include "gtkmain.h"
#include "gtkwidgetprivate.h"
-#include "gtkgesturemultipress.h"
#include "gtkeventcontrollermotion.h"
#include "gtkeventcontrollerkey.h"
#include "gtknative.h"
#include "gtklistbox.h"
#include "gtksizegroup.h"
#include "gtkroot.h"
-#include "gtkgesturemultipress.h"
+#include "gtkgestureclick.h"
#include "gtkstylecontext.h"
enum
}
static void
-sort_changed (GtkGestureMultiPress *gesture,
+sort_changed (GtkGestureClick *gesture,
int n_press,
double x,
double y,
<object class="GtkBox" id="name_heading">
<property name="hexpand">0</property>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<signal name="pressed" handler="sort_changed" swapped="no"/>
</object>
<object class="GtkBox" id="origin_heading">
<property name="hexpand">0</property>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<signal name="pressed" handler="sort_changed" swapped="no"/>
</object>
'gtkgesture.c',
'gtkgesturedrag.c',
'gtkgesturelongpress.c',
- 'gtkgesturemultipress.c',
+ 'gtkgestureclick.c',
'gtkgesturepan.c',
'gtkgesturerotate.c',
'gtkgesturesingle.c',
'gtkgesture.h',
'gtkgesturedrag.h',
'gtkgesturelongpress.h',
- 'gtkgesturemultipress.h',
+ 'gtkgestureclick.h',
'gtkgesturepan.h',
'gtkgesturerotate.h',
'gtkgesturesingle.h',
<property name="right-margin">8</property>
<property name="cursor-visible">0</property>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<signal name="released" handler="text_view_released" swapped="no"/>
</object>
</child>
<property name="right-margin">8</property>
<property name="cursor-visible">0</property>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<signal name="released" handler="text_view_released" swapped="no"/>
</object>
</child>
</object>
</child>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<property name="button">3</property>
<signal name="pressed" handler="pressed_cb"/>
</object>
</object>
</child>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<property name="button">3</property>
<signal name="pressed" handler="pressed_cb"/>
</object>
</object>
</child>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<property name="button">3</property>
<signal name="pressed" handler="pressed_cb"/>
</object>
</object>
</child>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<property name="button">3</property>
- <signal name="pressed" handler="multi_press_cb" swapped="no"/>
+ <signal name="pressed" handler="click_cb" swapped="no"/>
</object>
</child>
<child>
</object>
</child>
<child>
- <object class="GtkGestureMultiPress">
+ <object class="GtkGestureClick">
<property name="button">3</property>
<signal name="pressed" handler="pressed_cb" swapped="no"/>
</object>
gtk_widget_set_tooltip_text (image, "Click me");
GtkGesture *gesture;
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (icon_pressed_cb), NULL);
gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (gesture));
gtk_container_add (GTK_CONTAINER (box), image);
static GtkOrientation o;
static void
-toggle_orientation (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkGrid *grid)
+toggle_orientation (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkGrid *grid)
{
o = 1 - o;
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), o);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (toggle_orientation), grid);
gtk_widget_add_controller (window, GTK_EVENT_CONTROLLER (gesture));
gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (darea), 80);
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (darea), cursor_draw, NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), darea);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
g_signal_connect (gesture, "pressed", G_CALLBACK (cursor_pressed_cb), entry);
gtk_widget_add_controller (darea, GTK_EVENT_CONTROLLER (gesture));
}
static void
-press_handler (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkWidget *widget)
+press_handler (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkWidget *widget)
{
GtkTreePath *path = NULL;
tvc = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tvc);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture),
GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed",
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (pressed_cb), tree_view);
gtk_widget_add_controller (tree_view, GTK_EVENT_CONTROLLER (gesture));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE);
}
static void
-release_event (GtkGestureMultiPress *gesture,
- guint n_press,
- gdouble x,
- gdouble y,
- GtkTreeView *tv)
+release_event (GtkGestureClick *gesture,
+ guint n_press,
+ gdouble x,
+ gdouble y,
+ GtkTreeView *tv)
{
GtkTreePath *path;
gint tx, ty;
gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (store));
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_CAPTURE);
g_signal_connect (gesture, "released",
#include <gtk/gtk.h>
static void
-start_resize (GtkGestureMultiPress *gesture,
+start_resize (GtkGestureClick *gesture,
int n_press,
double x,
double y,
button = gtk_image_new_from_icon_name ("view-fullscreen-symbolic");
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_vexpand (button, TRUE);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (start_resize), GINT_TO_POINTER (edge));
gtk_widget_add_controller (button, GTK_EVENT_CONTROLLER (gesture));
}
static void
-start_move (GtkGestureMultiPress *gesture,
+start_move (GtkGestureClick *gesture,
int n_press,
double x,
double y,
button = gtk_image_new_from_icon_name ("view-grid-symbolic");
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_vexpand (button, TRUE);
- gesture = gtk_gesture_multi_press_new ();
+ gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (start_move), NULL);
gtk_widget_add_controller (button, GTK_EVENT_CONTROLLER (gesture));
data->str = str;
data->state = state;
- g = gtk_gesture_multi_press_new ();
+ g = gtk_gesture_click_new ();
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (g), FALSE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (g), 1);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (g), phase);
projects / gtk4.git / commitdiff